home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1998 January: Mac OS SDK / Dev.CD Jan 98 SDK1.toast / Development Kits (Disc 1) / Interfaces&Libraries / Universal / Interfaces / AIncludes / fenv.a < prev    next >
Encoding:
Text File  |  1997-08-12  |  11.6 KB  |  316 lines  |  [TEXT/MPS ]
  1. ;
  2. ;    File:        fenv.a
  3. ;
  4. ;    Contains:    Floating-Point environment for PowerPC and 68K
  5. ;
  6. ;    Version:    Technology:    MathLib v2
  7. ;                Release:    Universal Interfaces 3.0.1
  8. ;
  9. ;    Copyright:    © 1987-1997 by Apple Computer, Inc., all rights reserved.
  10. ;
  11. ;    Bugs?:        Please include the the file and version information (from above) with
  12. ;                the problem description.  Developers belonging to one of the Apple
  13. ;                developer programs can submit bug reports to:
  14. ;
  15. ;                    devsupport@apple.com
  16. ;
  17. ;
  18.     IF &TYPE('__FENV__') = 'UNDEFINED' THEN
  19. __FENV__ SET 1
  20.  
  21.     IF &TYPE('__CONDITIONALMACROS__') = 'UNDEFINED' THEN
  22.     include 'ConditionalMacros.a'
  23.     ENDIF
  24.  
  25. ; 
  26. ;        A collection of functions designed to provide access to the floating
  27. ;        point environment for numerical programming. It is modeled after
  28. ;        the floating-point requirements in C9X.
  29. ;        
  30. ;        The file <fenv.h> declares many functions in support of numerical
  31. ;        programming.  It provides a set of environmental controls similar to
  32. ;        the ones found in <SANE.h>.  Programs that test flags or run under
  33. ;        non-default modes must do so under the effect of an enabling
  34. ;        "fenv_access" pragma.
  35. ;
  36.  
  37.  
  38.     IF TARGET_CPU_PPC THEN
  39. ;     The typedef fenv_t is a type for representing the entire floating-point
  40. ;      environment in a single object.                                         
  41. ; typedef long                             fenv_t
  42.  
  43. ;     The typedef fexcept_t is a type for representing the floating-point
  44. ;      exception flag state collectively.                                      
  45. ; typedef long                             fexcept_t
  46.  
  47. ;     Definitions of floating-point exception macros                          
  48.  
  49. FE_INEXACT                        EQU        $02000000
  50. FE_DIVBYZERO                    EQU        $04000000
  51. FE_UNDERFLOW                    EQU        $08000000
  52. FE_OVERFLOW                        EQU        $10000000
  53. FE_INVALID                        EQU        $20000000
  54. ;     Definitions of rounding direction macros                                
  55.  
  56. FE_TONEAREST                    EQU        $00000000
  57. FE_TOWARDZERO                    EQU        $00000001
  58. FE_UPWARD                        EQU        $00000002
  59. FE_DOWNWARD                        EQU        $00000003
  60.     ENDIF    ; TARGET_CPU_PPC
  61.     IF TARGET_CPU_68K THEN
  62.     IF TARGET_RT_MAC_68881 THEN
  63. ; typedef long                             fexcept_t
  64.  
  65. fenv_t                    RECORD 0
  66. FPCR                     ds.l    1                ; offset: $0 (0)
  67. FPSR                     ds.l    1                ; offset: $4 (4)
  68. sizeof                     EQU *                    ; size:   $8 (8)
  69.                         ENDR
  70.  
  71. FE_INEXACT                        EQU        $00000008            ; ((long)(8))   
  72. FE_DIVBYZERO                    EQU        $00000010            ; ((long)(16))  
  73. FE_UNDERFLOW                    EQU        $00000020            ; ((long)(32))  
  74. FE_OVERFLOW                        EQU        $00000040            ; ((long)(64))  
  75. FE_INVALID                        EQU        $00000080            ; ((long)(128)) 
  76.     ELSE
  77. ; typedef short                         fexcept_t
  78.  
  79. ; typedef short                         fenv_t
  80.  
  81.  
  82. FE_INVALID                        EQU        $0001                ; ((short)(1))  
  83. FE_UNDERFLOW                    EQU        $0002                ; ((short)(2))  
  84. FE_OVERFLOW                        EQU        $0004                ; ((short)(4))  
  85. FE_DIVBYZERO                    EQU        $0008                ; ((short)(8))  
  86. FE_INEXACT                        EQU        $0010                ; ((short)(16)) 
  87.     ENDIF    ; TARGET_RT_MAC_68881
  88.  
  89. FE_TONEAREST                    EQU        $0000                ; ((short)(0))  
  90. FE_UPWARD                        EQU        $0001                ; ((short)(1))  
  91. FE_DOWNWARD                        EQU        $0002                ; ((short)(2))  
  92. FE_TOWARDZERO                    EQU        $0003                ; ((short)(3))  
  93. ;     Definitions of rounding precision macros  (68K only)                    
  94.  
  95. FE_LDBLPREC                        EQU        $0000                ; ((short)(0))  
  96. FE_DBLPREC                        EQU        $0001                ; ((short)(1))  
  97. FE_FLTPREC                        EQU        $0002                ; ((short)(2))  
  98.     ENDIF    ; TARGET_CPU_68K
  99. ;     The bitwise OR of all exception macros                                  
  100. ; *******************************************************************************
  101. ;*     The following functions provide access to the exception flags.  The      *
  102. ;*     "int" input argument can be constructed by bitwise ORs of the exception  *
  103. ;*     macros: for example: FE_OVERFLOW | FE_INEXACT.                           *
  104. ;******************************************************************************
  105.  
  106. ; *******************************************************************************
  107. ;*     The function "feclearexcept" clears the supported exceptions represented *
  108. ;*     by its argument.                                                         *
  109. ;******************************************************************************
  110.  
  111. ;
  112. ; extern void feclearexcept(int excepts)
  113. ;
  114.     IF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  115.         IMPORT_CFM_FUNCTION feclearexcept
  116.     ENDIF
  117.  
  118.  
  119.  
  120. ; *******************************************************************************
  121. ;*    The function "fegetexcept" stores a representation of the exception       *
  122. ;*     flags indicated by the argument "excepts" through the pointer argument   *
  123. ;*     "flagp".                                                                 *
  124. ;******************************************************************************
  125.  
  126. ;
  127. ; extern void fegetexcept(fexcept_t *flagp, int excepts)
  128. ;
  129.     IF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  130.         IMPORT_CFM_FUNCTION fegetexcept
  131.     ENDIF
  132.  
  133.  
  134.  
  135. ; *******************************************************************************
  136. ;*     The function "feraiseexcept" raises the supported exceptions             *
  137. ;*     represented by its argument.                                             *
  138. ;******************************************************************************
  139.  
  140. ;
  141. ; extern void feraiseexcept(int excepts)
  142. ;
  143.     IF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  144.         IMPORT_CFM_FUNCTION feraiseexcept
  145.     ENDIF
  146.  
  147.  
  148.  
  149. ; *******************************************************************************
  150. ;*     The function "fesetexcept" sets or clears the exception flags indicated  *
  151. ;*     by the int argument "excepts" according to the representation in the     *
  152. ;*     object pointed to by the pointer argument "flagp".  The value of         *
  153. ;*     "*flagp" must have been set by a previous call to "fegetexcept".         *
  154. ;*     This function does not raise exceptions; it just sets the state of       *
  155. ;*     the flags.                                                               *
  156. ;******************************************************************************
  157.  
  158. ;
  159. ; extern void fesetexcept(const fexcept_t *flagp, int excepts)
  160. ;
  161.     IF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  162.         IMPORT_CFM_FUNCTION fesetexcept
  163.     ENDIF
  164.  
  165.  
  166.  
  167. ; *******************************************************************************
  168. ;*     The function "fetestexcept" determines which of the specified subset of  *
  169. ;*     the exception flags are currently set.  The argument "excepts" specifies *
  170. ;*     the exception flags to be queried as a bitwise OR of the exception       *
  171. ;*     macros.  This function returns the bitwise OR of the exception macros    *
  172. ;*     corresponding to the currently set exceptions included in "excepts".     *
  173. ;******************************************************************************
  174.  
  175. ;
  176. ; extern int fetestexcept(int excepts)
  177. ;
  178.     IF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  179.         IMPORT_CFM_FUNCTION fetestexcept
  180.     ENDIF
  181.  
  182.  
  183.  
  184. ; *******************************************************************************
  185. ;*     The following functions provide control of rounding direction modes.     *
  186. ;******************************************************************************
  187.  
  188. ; *******************************************************************************
  189. ;*     The function "fegetround" returns the value of the rounding direction    *
  190. ;*     macro which represents the current rounding direction.                   *
  191. ;******************************************************************************
  192.  
  193. ;
  194. ; extern int fegetround(void )
  195. ;
  196.     IF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  197.         IMPORT_CFM_FUNCTION fegetround
  198.     ENDIF
  199.  
  200.  
  201.  
  202. ; *******************************************************************************
  203. ;*     The function "fesetround" establishes the rounding direction represented *
  204. ;*     by its argument.  It returns nonzero if and only if the argument matches *
  205. ;*     a rounding direction macro.  If not, the rounding direction is not       *
  206. ;*     changed.                                                                 *
  207. ;******************************************************************************
  208.  
  209. ;
  210. ; extern int fesetround(int round)
  211. ;
  212.     IF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  213.         IMPORT_CFM_FUNCTION fesetround
  214.     ENDIF
  215.  
  216.  
  217.  
  218. ; *******************************************************************************
  219. ;*    The following functions manage the floating-point environment, exception  *
  220. ;*    flags and dynamic modes, as one entity.                                   *
  221. ;******************************************************************************
  222.  
  223. ; *******************************************************************************
  224. ;*     The function "fegetenv" stores the current floating-point environment    *
  225. ;*     in the object pointed to by its pointer argument "envp".                 *
  226. ;******************************************************************************
  227.  
  228. ;
  229. ; extern void fegetenv(fenv_t *envp)
  230. ;
  231.     IF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  232.         IMPORT_CFM_FUNCTION fegetenv
  233.     ENDIF
  234.  
  235.  
  236.  
  237. ; *******************************************************************************
  238. ;*     The function "feholdexcept" saves the current environment in the object  *
  239. ;*     pointed to by its pointer argument "envp", clears the exception flags,   *
  240. ;*     and clears floating-point exception enables.  This function supersedes   *
  241. ;*     the SANE function "procentry", but it does not change the current        *
  242. ;*     rounding direction mode.                                                 *
  243. ;******************************************************************************
  244.  
  245. ;
  246. ; extern int feholdexcept(fenv_t *envp)
  247. ;
  248.     IF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  249.         IMPORT_CFM_FUNCTION feholdexcept
  250.     ENDIF
  251.  
  252.  
  253.  
  254. ; *******************************************************************************
  255. ;*     The function "fesetenv" installs the floating-point environment          *
  256. ;*     environment represented by the object pointed to by its argument         *
  257. ;*     "envp".  The value of "*envp" must be set by a call to "fegetenv" or     *
  258. ;*     "feholdexcept", by an implementation-defined macro of type "fenv_t",     *
  259. ;*     or by the use of the pointer macro FE_DFL_ENV as the argument.           *
  260. ;******************************************************************************
  261.  
  262. ;
  263. ; extern void fesetenv(const fenv_t *envp)
  264. ;
  265.     IF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  266.         IMPORT_CFM_FUNCTION fesetenv
  267.     ENDIF
  268.  
  269.  
  270.  
  271. ; *******************************************************************************
  272. ;*     The function "feupdateenv" saves the current exceptions into its         *
  273. ;*     automatic storage, installs the environment represented through its      *
  274. ;*     pointer argument "envp", and then re-raises the saved exceptions.        *
  275. ;*     This function, which supersedes the SANE function "procexit", can be     *
  276. ;*     used in conjunction with "feholdexcept" to write routines which hide     *
  277. ;*     spurious exceptions from their callers.                                  *
  278. ;******************************************************************************
  279.  
  280. ;
  281. ; extern void feupdateenv(const fenv_t *envp)
  282. ;
  283.     IF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  284.         IMPORT_CFM_FUNCTION feupdateenv
  285.     ENDIF
  286.  
  287.  
  288.  
  289.     IF TARGET_CPU_68K THEN
  290. ; *******************************************************************************
  291. ;*     The following functions provide control of rounding precision.           *
  292. ;*     Because the PowerPC does not provide this capability, these functions    *  
  293. ;*     are available only for the 68K Macintosh.  Rounding precision values     *
  294. ;*     are defined by the rounding precision macros.  These functions are       *
  295. ;*     equivalent to the SANE functions getprecision and setprecision.          *
  296. ;******************************************************************************
  297.  
  298. ;
  299. ; extern int fegetprec(void )
  300. ;
  301.     IF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  302.         IMPORT_CFM_FUNCTION fegetprec
  303.     ENDIF
  304.  
  305. ;
  306. ; extern int fesetprec(int precision)
  307. ;
  308.     IF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  309.         IMPORT_CFM_FUNCTION fesetprec
  310.     ENDIF
  311.  
  312.     ENDIF    ; TARGET_CPU_68K
  313.  
  314.     ENDIF ; __FENV__ 
  315.  
  316.